Overriding המחלקה למדעי המחשב עזאם מרעי אוניברסיטת בן-גוריון

Transcription

1 Overriding עזאם מרעי המחלקה למדעי המחשב אוניברסיטת בן-גוריון

2 2 Roadmap A method in a child class overrides a method in the parent class if it has the same name and type signature: Parent void method(int,float) Child void method(int,float) AnotherChild We will investigate some of the issues that arise from the use of overriding: Difference from Overloading Notations Replacement and Refinement Shadowing Covariance and Contravariance

3 3 Difference from Overloading Like overloading, there are two distinct methods with the same name But there are differences: Overriding only occurs in the context of the parent/child relationship overloading The type signatures must match overriding Overridden methods are sometimes combined together Overriding is resolved at run-time, not at compile time

4 4 Overriding Comparisons in Smalltalk An interesting example of overriding in found in class Magnitude in Smalltalk: <= arg ^ self < arg or: [ self = arg ] Magnitude >= arg ^ arg <= self Char Number Collection Point < arg ^ self <= arg and: [ self ~= arg ] Integer Fraction List Set Indexed Collection Array > arg ^ arg < self Float String Notice how these definitions are circular Child classes need only override one method to get effect of all relational

5 5 Overridden Relationals Child classes need only override one or two methods (for example <, >=) to get effect of all relational: Overridden in class Integer to mean integer less than Overridden in class Char to be ASCII ordering sequence Overridden in class String to mean lexicographic ordering Overridden in class Point to mean lower-left quadrant

6 6 Notating Overriding In some languages (Smalltalk, Java) overriding occurs automatically when a child class redefines a method with the same name and type signature. In some languages (C++) overriding will only occur if the parent class has declared the method in some special way (e.g. using the keyword virtual). In some languages (Object Pascal) overriding will only occur if the child class declares the method in some special way (e.g., using the keyword override). In some languages (C#, Delphi) overriding will only occur if both the parent and the child class declare the method in some special way. class Parent { // C# example public virtual int example (int a) {... class Child : Parent { public override int example (int a) {...

7 7 Replacement and Refinement There are actually two different ways that overriding can be handled: A replacement totally and completely replaces the code in the parent class the code in the child class A refinement executes the code in the parent class, and adds to it the code in the child class Most languages use both types of semantics in different situations Constructors, for example, almost always use refinement

8 8 Reasons to use Replacement There are a number of reasons to use replacement of methods: The method in the parent class is abstract, it must be replaced The method in the parent class is a default method, not appropriate for all situations The method in the parent can be more efficiently executed in the child We will give examples of the latter two.

9 9 Overriding a Default Method An example from Smalltalk: Class Number has child classes Integer, Fraction and Float. Method sqrt in class Number is defined as follows: "class Number" sqrt ^ self asfloat sqrt Integer Number sqrt Fraction Float sqrt In class Float we must perform something different, in this case actually computing the square root. The parent class has a method that will work in most, but not all, child classes

10 10 Overriding for Optimization An example where a child class can do the same action more efficiently than the parent class. Class Boolean has child classes True and False, and defines the following methods: "class Boolean" ` & right self iftrue: [ right iftrue: [ ^ true ] ]. ^ false right self iftrue: [ ^ true ]. right iftrue: [ ^ true ]. ^ false These very general algorithms will work for either true or false values

11 11 More Efficient Versions in class True In class True we know the left argument is true, and therefore can make more efficient algorithms: " class True " & right ^ right Number & right right ^ true True & right Float & right Similar code in class False. These are faster than the code in the parent class, but have the same effect.

12 12 Downside of Replacement The down side of replacement semantics is that there is no guarantee that the child class will have any meaning at all similar to the parent class For example, a child class could redefine sqrt to compute the cube root of its argument This goes back to the difference between subclasses and subtypes A refinement makes this error more difficult to do, since whatever the parent does is guaranteed to be part of the child This is why most languages use refinement semantics for constructors

13 13 Refinement in the Beta Programming Language Beta is interesting in that it always uses refinement. The parent method is always executed first. If it runs the special statement inner; then, at that point, the child method is executed. The child class can in turn do an inner, and so on arbitrarily. If a class has no child, then an inner statement has no effect.

14 14 Example, Print Anchors Here is an example, printing html anchor tags: class Anchor { public void printanchor () { print('<a href=" inner; print('">'); If we create an instance and call printanchor, the output we expect will be produced: Anchor a = new Anchor(); a.printanchor(); <A href="

15 15 Making Child Classes We can create child classes to any level: class BGUAnchor extends Anchor { public void printanchor () { print('// inner; class CourseAnchor extends BGUAnchor { public void printanchor () { print('~oosd172/'); inner; Anchor ananchor = new CourseAnchor(); anachor.printanchor(); <A href= Trace carefully the flow of control, and see how it differs from replacement

16 16 Simulating Refinement with Replacement In most languages the main features of a refinement can be simulated, even if the language uses replacement: void Parent::example (int a) { cout << "in parent code\n"; void Child::example (int a) { Parent::example(12); // do parent code cout << "in child code\n"; // then child code Note that this is not quite the same as Beta, as here the child wraps around the parent, while in Beta the parent wraps around the child

17 17 Constructors use Refinement In most languages that have constructors, a constructor will always use refinement This guarantees that whatever initialization the parent class performs will always be included as part of the initialization of the child class

18 18 Overriding versus Shadowing It is common in programming languages for one declaration of a variable to shadow a previous variable of the same name: class Silly { private int x; // an instance variable named x public void example (int x) { // x shadows instance variable int a = x+1; while (a > 3) { int x = 1; // local variable shadows parameter a = a - x; Shadowing can be resolved at compile time, does not require any run-time search

19 19 Shadowing of Instance Variables in Java Java allows instance variables to be redefined, and uses shadowing: class Parent { public int x = 12; class Child extend Parent { // shadows variable from parent class public int x = 42; The most important feature that distinguishes shadowing from overriding is that, like overloading, shadowing is resolved at compile time based on static types Parent p = new Parent(); System.out.println(p.x); 12 Child c = new Child(); System.out.println(c.x); 42 p = c; System.out.println(p.x); 12

20 20 Shadowing Methods Many of those languages (e.g., C++) that require the virtual keyword in the parent class will use shadowing if it is omitted: class Parent { public: // note, no virtual keyword here void example () { cout << "Parent" << endl; ; class Child : public Parent { public: void example () { cout << "Child" << endl; ; Parent * p = new Parent(); p->example() Parent Child * c = new Child(); c->example() Child p = c; // be careful here! p->example() Parent

21 21 Overriding, Shadowing and Redefinition of methods Overriding The type signatures are the same in both parent and child classes, and the method is declared as virtual in the parent class. Shadowing The type signatures are the same in both parent and child classes, but the method was not declared as virtual in the parent class. Redefinition The type signature in the child class differs from that given in the parent class.

22 22 Covariance and Contravariance Frequently it seems like it would be nice if when a method is overridden we could change the argument types or return types: A change that moves down the inheritance hierarchy, making it more specific, is said to be covariant A change that moves up the inheritance hierarchy is said to be contravariant class Parent { void test (covar : Mammal, contravar : Mammal) : boolean class Child extends Parent { void test (covar : Cat, contravar : Animal) : boolean While appealing, this idea runs into trouble with the principle of substitution: Parent avalue = new Child(); avalue.test(new Dog(), new Mammal()); // is this legal??

23 23 Example 2

24 24 Contravariant Return Types To see how a contravariant change can get you into trouble, consider changing the return types: class Parent { Mammal test ( ) { return new Cat(); class Child extends Parent { Animal test () { return new Bird(); Parent aparent = new Child(); Mammal result = avalue.test(); // is this legal? Most languages subscribe to the novariance rule: no change in type signatures

25 25 A Safe Variance Change C++ allows the following type of change in signature: class Parent { public: Parent * clone () { return new Parent(); ; class Child : public Parent { public: Child * clone () { return new Child(); ; No type errors can result from this change

26 26 Java public class C1 { public C1 foo() { System.out.println("I am in C1"); return new C1(); public class C2 extends C1 { public C2 foo() { System.out.println("I am in C2"); return new C2(); C1 c = new C2(); c.foo(); am in C2 The Java language feature of covariant return types explicitly does not apply to primitives.

27 27 Chapter Summary An override occurs when a method in the child classes uses the same name and type signature as a method in the parent class. Unlike overloading, overriding is resolved at run-time. There are two possible means for an overriding, replacement and refinement. A name can shadow another name. Some languages permit both shadowing and overriding. Shadowing is resolved at compile time. A change in the type signature can be covariant or contravariant, if it moves down or up the type hierarchy. The semantics of both types of change can be subtle.